package cn.peng.stu4teach.pages.funcs;

import android.app.Activity;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.os.Handler;
import android.text.TextUtils;
import android.view.View;

import androidx.annotation.NonNull;
import androidx.databinding.ObservableField;
import androidx.lifecycle.AndroidViewModel;
import androidx.localbroadcastmanager.content.LocalBroadcastManager;
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;

import com.blankj.utilcode.util.GsonUtils;
import com.blankj.utilcode.util.LogUtils;
import com.blankj.utilcode.util.SPUtils;
import com.blankj.utilcode.util.ToastUtils;

import java.util.ArrayList;
import java.util.List;

import cn.peng.stu4teach.bizutil.BizConst;
import cn.peng.stu4teach.pages.home.bean.FuncsBean;

/**
 * 功用："全部功能" 页面中使用的Vm
 */
public class AllFuncsVm extends AndroidViewModel {
    /**
     * 在执行搜索操作之前的常用功能数据，执行搜索操作时，将数据临时存储在这里
     */
    private final ArrayList<FuncsBean> commonFunsBeforeSearch = new ArrayList<>();
    /**
     * 执行搜索操作之前的全部功能数据，执行搜索时，将数据临时存储在这里
     */
    private final ArrayList<FuncsBean> allFuncsBeforeSearch   = new ArrayList<>();

    /**
     * 常用功能集合
     */
    public ArrayList<FuncsBean> commonUseFuncs = new ArrayList<>();
    /**
     * 全部功能集合
     */
    public ArrayList<FuncsBean> allFuncs       = new ArrayList<>();

    /**
     * 是否处于编辑状态
     */
    public  ObservableField<Boolean> onEditing = new ObservableField<>(false);
    /**
     * 搜索框中的关键字
     */
    public  ObservableField<String>  searchKey = new ObservableField<>("");
    /**
     * 常用功能使用的适配器
     */
    private FuncsAdapter             mCommRvAdapter;
    /**
     * 全部功能使用的适配器
     */
    private FuncsAdapter             mAllRvAdapter;

    public AllFuncsVm (@NonNull Application application) {
        super(application);
    }


    /**
     * 执行初始化操作
     */
    public void init () {
        getCommonFuncs();
        getAllFuncs();
    }

    /**
     * 获取常用功能
     */
    private void getCommonFuncs () {
        String preDataStr = SPUtils.getInstance(BizConst.SP_NAME_COMM_FUNCS).getString(BizConst.SP_KEY_COMM_FUNCS, "");
        List<FuncsBean> preCommFuncs = GsonUtils.fromJson(preDataStr, GsonUtils.getListType(FuncsBean.class));

        if (!preCommFuncs.isEmpty()) {
            commonUseFuncs.addAll(preCommFuncs);
        }
    }

    /**
     * 从服务端获取全部的功能
     */
    private void getAllFuncs () {
        String[] names1 = {"巡更", "巡检", "报事报修", "维修指派", "公区验收", "房产验收"};
        String[] names2 = {"物资申领", "请假", "门禁录入", "用章申请", "工资单"};
        String[] names3 = {"规章制度", "奖惩办法", "操作准则", "公司发文"};
        // 二维数组
        String[][] nameArrArr = {names1, names2, names3};

        List<FuncsBean> list = new ArrayList<FuncsBean>();
        for (int i = 0; i < nameArrArr.length; i++) {
            switch (i) {
                case 0:
                    list.add(new FuncsBean("业务功能", true));
                    break;
                case 1:
                    list.add(new FuncsBean("日常办公", true));
                    break;
                default:
                    list.add(new FuncsBean("公司制度", true));
                    break;
            }

            String[] names = nameArrArr[i];
            for (int j = 0; j < names.length; j++) {
                list.add(new FuncsBean("recordId-" + j, names[j], "", ""));
            }
        }

        allFuncs.addAll(list);
    }

    /**
     * 界面右上角的编辑按钮被点击了
     */
    public void onEditBtnClick () {
        if (null == onEditing) {
            return;
        }
        Boolean flag = onEditing.get();
        if (null == flag) {
            return;
        }

        // 点击之后对当前状态取反
        onEditing.set(!flag);

        // 如果正在编辑，点击后，表示完成编辑，要保存数据；如果不是正在编辑，点击后，表示要开始编辑。
        if (flag) {
            // “完成”-保存数据，并通知 HomeFm
            String funcsStr = GsonUtils.toJson(commonUseFuncs);
            SPUtils.getInstance(BizConst.SP_NAME_COMM_FUNCS).put(BizConst.SP_KEY_COMM_FUNCS, funcsStr);
            sendBroadcast2HomeFm(funcsStr);
        } else {
            ToastUtils.showShort("编辑中将禁用搜索功能");
            // 开始编辑，判断 全部功能中的条目 是否在 常用功能 中，是则更改其 inCommon 值
            List<String> commFuncNames = new ArrayList<>();
            for (FuncsBean commFunc : commonUseFuncs) {
                commFuncNames.add(commFunc.name);
            }

            for (int i = 0; i < allFuncs.size(); i++) {
                FuncsBean func = allFuncs.get(i);
                if (commFuncNames.contains(func.name)) {
                    func.inCommon = true;
                    allFuncs.set(i, func);
                    mAllRvAdapter.notifyItemChanged(i);
                }
            }
        }
    }

    /**
     * 点击了搜索按钮，执行本地搜索逻辑
     */
    public void onSearch (String key) {
        if (null == onEditing || null == onEditing.get() || Boolean.TRUE.equals(onEditing.get())) {
            ToastUtils.showShort("编辑状态不支持搜索");
            return;
        }

        if (TextUtils.isEmpty(key)) {
            // 搜索关键字为空时，不执行搜索操作
            return;
        }
        LogUtils.d("搜索关键字发生了变化 2--搜索关键字为:", key);

        // 将现有数据进行存储，方便清除 searchKey 时恢复数据。
        commonFunsBeforeSearch.addAll(commonUseFuncs);
        allFuncsBeforeSearch.addAll(allFuncs);

        // 搜索常用功能并更新界面（遍历比对）
        ArrayList<FuncsBean> searchedCommonFuncs = new ArrayList<>();
        for (FuncsBean commonFunc : commonUseFuncs) {
            if (null != commonFunc && commonFunc.name.contains(key)) {
                searchedCommonFuncs.add(commonFunc);
            }
        }
        commonUseFuncs.clear();
        commonUseFuncs.addAll(searchedCommonFuncs);
        mCommRvAdapter.setItems(commonUseFuncs);

        // 搜索全部功能并更新（遍历比对）
        ArrayList<FuncsBean> searchedAllFuncs = new ArrayList<>();
        for (FuncsBean func : allFuncs) {
            if (null != func && func.name.contains(key)) {
                searchedAllFuncs.add(func);
            }
        }
        allFuncs.clear();
        allFuncs.addAll(searchedAllFuncs);
        mAllRvAdapter.setItems(allFuncs);
    }

    /**
     * 清空了搜索框中的内容
     */
    public void onClearSearchKey (String curKey) {
        if (TextUtils.isEmpty(curKey)) {
            // 如果当前搜索框中没有任何关键字，不执行操作
            return;
        }
        searchKey.set("");
        LogUtils.d("搜索关键字发生了变化 3--搜索框被清空了:");

        // 清除搜索框之后，还原数据
        if (!commonFunsBeforeSearch.isEmpty()) {
            commonUseFuncs.clear();
            commonUseFuncs.addAll(commonFunsBeforeSearch);
            mCommRvAdapter.setItems(commonUseFuncs);
        }

        if (!allFuncsBeforeSearch.isEmpty()) {
            allFuncs.clear();
            allFuncs.addAll(allFuncsBeforeSearch);
            mAllRvAdapter.setItems(allFuncs);
        }
    }

    /**
     * 动态获取 LayoutManager 调整每行所展示的列数。
     */
    public GridLayoutManager getLayoutManager (Context pCtx) {
        int spanCount = 4;
        GridLayoutManager layoutManager = new GridLayoutManager(pCtx, spanCount);
        layoutManager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
            @Override
            public int getSpanSize (int position) {
                FuncsBean funcBean = allFuncs.get(position);
                return funcBean.isGroupTitle ? spanCount : 1;
            }
        });
        return layoutManager;
    }

    /**
     * 返回按钮被点击了
     */
    public void onBackClick (Context pCtx) {
        if (null == pCtx) {
            return;
        }

        Activity act = (Activity) pCtx;
        act.finish();
    }

    /**
     * 发送本地广播，通知 HomeFm 刷新常用功能列表
     */
    private void sendBroadcast2HomeFm (String funcsStr) {
        Intent intent = new Intent();
        intent.setAction(BizConst.BROADCAST_KEY_COMM_FUNC_CHANGED);
        intent.putExtra(BizConst.SP_KEY_COMM_FUNCS, funcsStr);
        LocalBroadcastManager.getInstance(getApplication()).sendBroadcast(intent);
    }

    /**
     * "所有功能"中的条目被点击了
     */
    public void onItemClickInAll (Context pCtx, FuncsBean pItem, int pPos) {
        if (null == pItem) {
            return;
        }

        Boolean flag = onEditing.get();
        if (null == flag) {
            return;
        }

        if (!flag) {
            // TODO 非编辑状态，点击直接跳转

            return;
        }

        // 如果处于编辑状态
        if (pItem.inCommon) {
            // 如果已经存在于常用功能中，点击不做任何操作
            return;
        }

        // 常用功能最多支持 7 个
        if (commonUseFuncs.size() == 7) {
            ToastUtils.showShort("最多添加7个常用功能");
            return;
        }

        // 如果不在常用功能中，更改其状态(已经添加到常用功能的状态）,并添加到常用功能中，
        pItem.inCommon = true;
        commonUseFuncs.add(pItem);
        mCommRvAdapter.notifyItemInserted(commonUseFuncs.size() - 1);

        // 更新 allFuncs 中的数据
        allFuncs.set(pPos, pItem);
        mAllRvAdapter.notifyItemChanged(pPos, pItem);
    }

    /**
     * "常用功能"中的条目被点击了
     */
    public void onItemClickInComm (Context pCtx, FuncsBean pItem, int pRealPos) {
        if (null == pItem) {
            return;
        }

        Boolean flag = onEditing.get();
        if (null == flag) {
            return;
        }

        if (!flag) {
            // TODO 非编辑状态，点击直接跳转

            return;
        }

        // 如果处于编辑状态
        // 点击之后从常用功能中移除，
        if (commonUseFuncs.size() == 1) {
            ToastUtils.showShort("至少保留一个常用功能");
            return;
        }
        commonUseFuncs.remove(pItem);
        mCommRvAdapter.setItems(commonUseFuncs);

        // 并更改全部功能中该条目的状态（inCommon 状态）
        for (int i = 0; i < allFuncs.size(); i++) {
            FuncsBean func = allFuncs.get(i);
            if (func.name.equals(pItem.name)) {
                pItem.inCommon = false;
                allFuncs.set(i, pItem);
                mAllRvAdapter.notifyItemChanged(i, pItem);
            }
        }
    }

    /**
     * 条目被点击了
     */
    public void onItemClick (View pView, FuncsBean pItem, int pRealPos, String pRvType) {
        if (null == pItem) {
            return;
        }
        if ("comm".equals(pRvType)) {
            onItemClickInComm(pView.getContext(), pItem, pRealPos);
            return;
        }

        onItemClickInAll(pView.getContext(), pItem, pRealPos);
    }

    public void initRv (RecyclerView pRv, String type) {
        FuncsAdapter adapter = new FuncsAdapter(this, type);
        pRv.setAdapter(adapter);

        new Handler().postDelayed(new Runnable() {
            @Override
            public void run () {
                if ("comm".equals(type)) {
                    adapter.setItems(commonUseFuncs);
                    mCommRvAdapter = adapter;
                } else {
                    adapter.setItems(allFuncs);
                    mAllRvAdapter = adapter;
                }
            }
        }, 2000);

    }
}
